| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326 |
2x
2x
2x
2x
24838x
2x
43409x
38918x
4491x
43409x
38920x
4489x
43409x
43409x
43409x
2x
18571x
18571x
18571x
2x
1572682x
2x
10785x
2x
14082x
14082x
3989x
7323x
10093x
10093x
14082x
2x
158382x
2x
3008x
3008x
3008x
2x
1481x
1481x
2x
4446x
4446x
2x
1565x
1565x
2x
683514x
683514x
2x
108602x
2x
4517x
9x
4508x
4676x
15x
4493x
2x
99055x
102561x
2x
43680x
2x
161404x
161404x
316531x
316531x
316531x
283056x
50710x
50667x
50160x
2x
2x
2x
27400x
2x
16397x
2x
4402x
24x
22952x
4378x
2x
2x
2x
2x
2x
3950x
2x
3743x
3950x
3950x
88x
3950x
2x
160x
2x
13481x
2x
6x
2x
598x
598x
598x
598x
658x
4x
654x
654x
598x
598x
4179x
4179x
12x
1x
11x
11x
1x
10x
10x
4167x
44x
44x
4123x
64x
62x
4059x
4059x
594x
592x
592x
2x
2x
| /**
* Copyright 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { assert, fail } from '../util/assert';
import { Code, FirestoreError } from '../util/error';
export const DOCUMENT_KEY_NAME = '__name__';
/**
* Path represents an ordered sequence of string segments.
*/
export abstract class Path {
private segments: string[];
private offset: number;
private len: number;
constructor(segments: string[], offset?: number, length?: number) {
this.init(segments, offset, length);
}
/**
* An initialization method that can be called from outside the constructor.
* We need this so that we can have a non-static construct method that returns
* the polymorphic `this` type.
*/
private init(segments: string[], offset?: number, length?: number) {
if (offset === undefined) {
offset = 0;
} else Iif (offset > segments.length) {
fail('offset ' + offset + ' out of range ' + segments.length);
}
if (length === undefined) {
length = segments.length - offset;
} else Iif (length > segments.length - offset) {
fail('length ' + length + ' out of range ' + (segments.length - offset));
}
this.segments = segments;
this.offset = offset;
this.len = length;
}
/**
* Constructs a new instance of Path using the same concrete type as `this`.
* We need this instead of using the normal constructor, because polymorphic
* `this` doesn't work on static methods.
*/
private construct(
segments: string[],
offset?: number,
length?: number
): this {
const path: this = Object.create(Object.getPrototypeOf(this));
path.init(segments, offset, length);
return path;
}
get length(): number {
return this.len;
}
isEqual(other: Path): boolean {
return Path.comparator(this, other) === 0;
}
child(nameOrPath: string | this): this {
const segments = this.segments.slice(this.offset, this.limit());
if (nameOrPath instanceof Path) {
nameOrPath.forEach(segment => {
segments.push(segment);
});
} else Eif (typeof nameOrPath === 'string') {
segments.push(nameOrPath);
} else {
fail('Unknown parameter type for Path.child(): ' + nameOrPath);
}
return this.construct(segments);
}
/** The index of one past the last segment of the path. */
private limit(): number {
return this.offset + this.length;
}
popFirst(size?: number): this {
size = size === undefined ? 1 : size;
assert(this.length >= size, "Can't call popFirst() with less segments");
return this.construct(
this.segments,
this.offset + size,
this.length - size
);
}
popLast(): this {
assert(!this.isEmpty(), "Can't call popLast() on empty path");
return this.construct(this.segments, this.offset, this.length - 1);
}
firstSegment(): string {
assert(!this.isEmpty(), "Can't call firstSegment() on empty path");
return this.segments[this.offset];
}
lastSegment(): string {
assert(!this.isEmpty(), "Can't call lastSegment() on empty path");
return this.segments[this.limit() - 1];
}
get(index: number): string {
assert(index < this.length, 'Index out of range');
return this.segments[this.offset + index];
}
isEmpty(): boolean {
return this.length === 0;
}
isPrefixOf(other: this): boolean {
if (other.length < this.length) {
return false;
}
for (let i = 0; i < this.length; i++) {
if (this.get(i) !== other.get(i)) {
return false;
}
}
return true;
}
forEach(fn: (segment: string) => void): void {
for (let i = this.offset, end = this.limit(); i < end; i++) {
fn(this.segments[i]);
}
}
toArray(): string[] {
return this.segments.slice(this.offset, this.limit());
}
static comparator(p1: Path, p2: Path): number {
const len = Math.min(p1.length, p2.length);
for (let i = 0; i < len; i++) {
const left = p1.get(i);
const right = p2.get(i);
if (left < right) return -1;
if (left > right) return 1;
}
if (p1.length < p2.length) return -1;
if (p1.length > p2.length) return 1;
return 0;
}
}
/**
* A slash-separated path for navigating resources (documents and collections)
* within Firestore.
*/
export class ResourcePath extends Path {
canonicalString(): string {
// NOTE: The client is ignorant of any path segments containing escape
// sequences (e.g. __id123__) and just passes them through raw (they exist
// for legacy reasons and should not be used frequently).
return this.toArray().join('/');
}
toString(): string {
return this.canonicalString();
}
/**
* Creates a resource path from the given slash-delimited string.
*/
static fromString(path: string): ResourcePath {
// NOTE: The client is ignorant of any path segments containing escape
// sequences (e.g. __id123__) and just passes them through raw (they exist
// for legacy reasons and should not be used frequently).
if (path.indexOf('//') >= 0) {
throw new FirestoreError(
Code.INVALID_ARGUMENT,
`Invalid path (${path}). Paths must not contain // in them.`
);
}
// We may still have an empty segment at the beginning or end if they had a
// leading or trailing slash (which we allow).
const segments = path.split('/').filter(segment => segment.length > 0);
return new ResourcePath(segments);
}
static EMPTY_PATH = new ResourcePath([]);
}
const identifierRegExp = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
/** A dot-separated path for navigating sub-objects within a document. */
export class FieldPath extends Path {
/**
* Returns true if the string could be used as a segment in a field path
* without escaping.
*/
private static isValidIdentifier(segment: string) {
return identifierRegExp.test(segment);
}
canonicalString(): string {
return this.toArray()
.map(str => {
str = str.replace('\\', '\\\\').replace('`', '\\`');
if (!FieldPath.isValidIdentifier(str)) {
str = '`' + str + '`';
}
return str;
})
.join('.');
}
toString(): string {
return this.canonicalString();
}
/**
* Returns true if this field references the key of a document.
*/
isKeyField(): boolean {
return this.length === 1 && this.get(0) === DOCUMENT_KEY_NAME;
}
/**
* The field designating the key of a document.
*/
static keyField(): FieldPath {
return new FieldPath([DOCUMENT_KEY_NAME]);
}
/**
* Parses a field string from the given server-formatted string.
*
* - Splitting the empty string is not allowed (for now at least).
* - Empty segments within the string (e.g. if there are two consecutive
* separators) are not allowed.
*
* TODO(b/37244157): we should make this more strict. Right now, it allows
* non-identifier path components, even if they aren't escaped.
*/
static fromServerFormat(path: string): FieldPath {
const segments: string[] = [];
let current = '';
let i = 0;
const addCurrentSegment = () => {
if (current.length === 0) {
throw new FirestoreError(
Code.INVALID_ARGUMENT,
`Invalid field path (${path}). Paths must not be empty, begin ` +
`with '.', end with '.', or contain '..'`
);
}
segments.push(current);
current = '';
};
let inBackticks = false;
while (i < path.length) {
const c = path[i];
if (c === '\\') {
if (i + 1 === path.length) {
throw new FirestoreError(
Code.INVALID_ARGUMENT,
'Path has trailing escape character: ' + path
);
}
const next = path[i + 1];
if (!(next === '\\' || next === '.' || next === '`')) {
throw new FirestoreError(
Code.INVALID_ARGUMENT,
'Path has invalid escape sequence: ' + path
);
}
current += next;
i += 2;
} else if (c === '`') {
inBackticks = !inBackticks;
i++;
} else if (c === '.' && !inBackticks) {
addCurrentSegment();
i++;
} else {
current += c;
i++;
}
}
addCurrentSegment();
Iif (inBackticks) {
throw new FirestoreError(
Code.INVALID_ARGUMENT,
'Unterminated ` in path: ' + path
);
}
return new FieldPath(segments);
}
static EMPTY_PATH = new FieldPath([]);
}
|